const express = require('express'); // 导入express
const mongoose = require('mongoose'); // 导入mongoose
const cors = require('cors'); // 导入cors用于跨域
const app = express(); // 创建express应用
const PORT = 3001; // 端口

app.use(cors()); // 启用跨域
app.use(express.json()); // 解析json

// 连接MongoDB
mongoose.connect('mongodb://localhost:27017/gmv_demo', {
  useNewUrlParser: true,
  useUnifiedTopology: true
});

// 定义订单Schema
const orderSchema = new mongoose.Schema({
  orderNo: String,
  customerName: String,
  amount: Number,
  status: String,
  paymentMethod: String,
  orderTime: Date,
  products: [
    {
      name: String,
      price: Number,
      quantity: Number
    }
  ]
});

// 创建订单模型
const Order = mongoose.model('Order', orderSchema);

// 商品Schema
const productSchema = new mongoose.Schema({
  name: String,         // 商品名称
  category: String,     // 商品分类
  stock: Number,        // 库存
  price: Number,        // 单价
  warning: { type: Number, default: 20 } // 预警值，默认20
});
const Product = mongoose.model('Product', productSchema);

// 1. 定义用户Schema
const userSchema = new mongoose.Schema({
  username: String, // 用户名
  password: String, // 密码（明文仅演示，实际应加密）
  role: { type: String, enum: ['admin', 'employee'], default: 'employee' }, // 角色
  realName: String, // 真实姓名
  createTime: { type: Date, default: Date.now } // 创建时间
});
// 2. 创建用户模型
const User = mongoose.model('User', userSchema);

// 获取今日GMV数据API
app.get('/api/gmv/today', async (req, res) => {
  try {
    // 获取当天0点和24点
    const start = new Date();
    start.setHours(0, 0, 0, 0);
    const end = new Date();
    end.setHours(23, 59, 59, 999);

    // 查询今日订单
    const orders = await Order.find({
      orderTime: { $gte: start, $lte: end }
    }).sort({ orderTime: -1 });

    // 汇总数据
    let totalAmount = 0;
    let totalOrders = orders.length;
    let completedOrders = 0;
    orders.forEach(order => {
      totalAmount += order.amount;
      if (order.status === '已完成') completedOrders++;
    });

    res.json({
      orders,
      summary: {
        totalAmount,
        totalOrders,
        completedOrders,
        averageAmount: totalOrders > 0 ? Math.round(totalAmount / totalOrders) : 0
      }
    });
  } catch (err) {
    res.status(500).json({ error: '服务器错误' });
  }
});

// 数据初始化API
app.post('/api/init-data', async (req, res) => {
  try {
    console.log('开始初始化订单数据...'); // 开始提示
    
    // 清空现有数据
    await Order.deleteMany({}); // 删除所有现有订单
    console.log('已清空现有订单数据'); // 清空提示
    
    // 生成订单数据
    const customers = ['张三', '李四', '王五', '赵六', '孙七', '周八', '吴九', '郑十', '钱十一', '孙十二', '周十三', '吴十四'];
    const products = [
      { name: 'iPhone 15 Pro', price: 8999 },
      { name: '小米电视 65寸', price: 2999 },
      { name: '华为Mate60 Pro', price: 6999 },
      { name: '联想ThinkPad X1', price: 12999 },
      { name: '美的空调 1.5匹', price: 2499 },
      { name: '戴尔显示器 27寸', price: 1899 },
      { name: '苹果MacBook Air', price: 7999 },
      { name: '索尼PS5', price: 3899 },
      { name: '三星Galaxy S24', price: 5999 },
      { name: '小米14 Ultra', price: 6499 },
      { name: 'OPPO Find X7', price: 5499 },
      { name: 'vivo X100 Pro', price: 5999 }
    ];
    const paymentMethods = ['支付宝', '微信支付', '银行卡', '现金'];
    const statuses = ['待付款', '已付款', '待发货', '已发货', '已完成', '已取消'];
    
    const orders = []; // 订单数组
    const today = new Date(); // 获取今天日期
    
    // 生成50-100条随机订单
    const orderCount = Math.floor(Math.random() * 51) + 50; // 50-100条订单
    
    for (let i = 0; i < orderCount; i++) {
      // 生成今天随机时间
      const orderTime = new Date(today.getTime() + Math.random() * 24 * 60 * 60 * 1000);
      const productCount = Math.floor(Math.random() * 3) + 1; // 1-3个商品
      const orderProducts = []; // 订单商品数组
      let orderAmount = 0; // 订单金额
      
      // 生成订单商品
      for (let j = 0; j < productCount; j++) {
        const product = products[Math.floor(Math.random() * products.length)]; // 随机选择商品
        const quantity = Math.floor(Math.random() * 3) + 1; // 1-3个数量
        orderProducts.push({
          name: product.name,
          price: product.price,
          quantity: quantity
        });
        orderAmount += product.price * quantity; // 计算订单金额
      }
      
      // 生成订单编号
      const orderNo = `GMV${today.getFullYear()}${String(today.getMonth() + 1).padStart(2, '0')}${String(today.getDate()).padStart(2, '0')}${String(i + 1).padStart(4, '0')}`;
      
      orders.push({
        orderNo: orderNo, // 订单编号
        customerName: customers[Math.floor(Math.random() * customers.length)], // 客户姓名
        amount: orderAmount, // 订单金额
        status: statuses[Math.floor(Math.random() * statuses.length)], // 订单状态
        paymentMethod: paymentMethods[Math.floor(Math.random() * paymentMethods.length)], // 支付方式
        orderTime: orderTime, // 下单时间
        products: orderProducts // 商品信息
      });
    }
    
    // 插入数据到数据库
    await Order.insertMany(orders); // 批量插入订单
    console.log('订单数据已成功插入MongoDB'); // 插入成功提示
    
    // 验证数据
    const count = await Order.countDocuments(); // 统计订单数量
    
    res.json({ 
      success: true, 
      message: '数据初始化成功', 
      orderCount: count 
    }); // 返回成功响应
    
  } catch (err) {
    console.error('数据初始化失败:', err); // 错误日志
    res.status(500).json({ error: '数据初始化失败' }); // 返回错误响应
  }
});

// 获取商品列表及今日销量API
app.get('/api/products', async (req, res) => {
  try {
    // 获取所有商品
    const products = await Product.find();

    // 获取今日订单
    const start = new Date();
    start.setHours(0, 0, 0, 0);
    const end = new Date();
    end.setHours(23, 59, 59, 999);
    const todayOrders = await Order.find({
      orderTime: { $gte: start, $lte: end }
    });

    // 统计每个商品的今日销量
    const salesMap = {};
    todayOrders.forEach(order => {
      order.products.forEach(item => {
        salesMap[item.name] = (salesMap[item.name] || 0) + item.quantity;
      });
    });

    // 组装返回数据
    const result = products.map(prod => ({
      ...prod.toObject(),
      todaySales: salesMap[prod.name] || 0
    }));

    res.json(result);
  } catch (err) {
    res.status(500).json({ error: '服务器错误' });
  }
});

// 商品销量排行API（只统计已完成/已付款订单）
app.get('/api/products/rank', async (req, res) => {
  try {
    const products = await Product.find();
    const start = new Date();
    start.setHours(0, 0, 0, 0);
    const end = new Date();
    end.setHours(23, 59, 59, 999);
    // 只统计已完成/已付款订单
    const todayOrders = await Order.find({
      orderTime: { $gte: start, $lte: end },
      status: { $in: ['已完成', '已付款'] }
    });
    const salesMap = {};
    todayOrders.forEach(order => {
      order.products.forEach(item => {
        salesMap[item.name] = (salesMap[item.name] || 0) + item.quantity;
      });
    });
    const result = products.map(prod => ({
      ...prod.toObject(),
      todaySales: salesMap[prod.name] || 0
    })).sort((a, b) => b.todaySales - a.todaySales);
    res.json(result);
  } catch (err) {
    res.status(500).json({ error: '服务器错误' });
  }
});

// 修改商品库存（增加/减少delta，不能为负数）
app.put('/api/products/:id/stock', async (req, res) => {
  try {
    const { delta } = req.body;
    if (typeof delta !== 'number') {
      return res.status(400).json({ error: 'delta必须为数字' });
    }
    const product = await Product.findById(req.params.id);
    if (!product) return res.status(404).json({ error: '商品不存在' });
    const newStock = product.stock + delta;
    if (newStock < 0) {
      return res.status(400).json({ error: '库存不能为负数' });
    }
    product.stock = newStock;
    await product.save();
    res.json({ success: true, stock: product.stock });
  } catch (err) {
    res.status(500).json({ error: '服务器错误' });
  }
});

// 直接设置商品库存
app.put('/api/products/:id/set-stock', async (req, res) => {
  try {
    const { stock } = req.body;
    if (typeof stock !== 'number' || stock < 0) {
      return res.status(400).json({ error: '库存必须为非负整数' });
    }
    const product = await Product.findById(req.params.id);
    if (!product) return res.status(404).json({ error: '商品不存在' });
    product.stock = stock;
    await product.save();
    res.json({ success: true, stock: product.stock });
  } catch (err) {
    res.status(500).json({ error: '服务器错误' });
  }
});

// 删除商品
app.delete('/api/products/:id', async (req, res) => {
  try {
    await Product.findByIdAndDelete(req.params.id);
    res.json({ success: true });
  } catch (err) {
    res.status(500).json({ error: '服务器错误' });
  }
});

// 3. 创建用户API
app.post('/api/users', async (req, res) => {
  try {
    const { username, password, role, realName } = req.body; // 获取请求体参数
    if (!username || !password || !role) {
      return res.status(400).json({ error: '用户名、密码和角色必填' });
    }
    // 检查用户名是否已存在
    const exist = await User.findOne({ username });
    if (exist) {
      return res.status(400).json({ error: '用户名已存在' });
    }
    // 创建新用户
    const user = new User({ username, password, role, realName });
    await user.save();
    res.json({ success: true, user });
  } catch (err) {
    res.status(500).json({ error: '创建用户失败' });
  }
});

// 4. 登录API
app.post('/api/login', async (req, res) => {
  try {
    const { username, password } = req.body; // 获取用户名和密码
    const user = await User.findOne({ username, password }); // 查找用户
    if (!user) {
      return res.status(401).json({ error: '用户名或密码错误' });
    }
    // 登录成功，返回用户信息（不返回密码）
    res.json({ success: true, user: { _id: user._id, username: user.username, role: user.role, realName: user.realName } });
  } catch (err) {
    res.status(500).json({ error: '登录失败' });
  }
});

// 5. 退出登录API（前端只需清除本地token/session即可，这里返回成功）
app.post('/api/logout', (req, res) => {
  res.json({ success: true });
});

// 设置商品预警值API
app.put('/api/products/:id/set-warning', async (req, res) => {
  try {
    const { warning } = req.body; // 获取预警值
    if (typeof warning !== 'number' || warning < 0) {
      return res.status(400).json({ error: '预警值必须为非负数字' });
    }
    const product = await Product.findByIdAndUpdate(req.params.id, { warning }, { new: true });
    if (!product) return res.status(404).json({ error: '商品不存在' });
    res.json({ success: true, product });
  } catch (err) {
    res.status(500).json({ error: '设置预警值失败' });
  }
});

// 启动服务前自动初始化管理员账号
(async () => {
  try {
    const admin = await User.findOne({ username: 'admin' }); // 查找admin用户
    if (!admin) {
      await User.create({ username: 'admin', password: 'admin123', role: 'admin', realName: '系统管理员' }); // 创建admin用户
      console.log('已自动初始化管理员账号：admin/admin123'); // 控制台提示
    }
  } catch (err) {
    console.error('初始化管理员账号失败:', err); // 错误日志
  }
})();

// 启动服务
app.listen(PORT, () => {
  console.log(`Server running at http://localhost:${PORT}`);
}); 